package com.sparrow.common.util;

public class NumberUtil {

    /**
     * 安全地将 long 类型转换为 int 类型。
     * 如果 long 值超出 int 的范围，则返回 int 的最大值或最小值。
     *
     * @param value 要转换的 long 值
     * @return 转换后的 int 值
     */
    public static int safeToInt(long value) {
        if (value > Integer.MAX_VALUE) {
            return Integer.MAX_VALUE;
        }
        if (value < Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        }
        return (int) value;
    }

    /**
     * 将指定位置的二进制位设置为 1。
     *
     * @param src       源整数
     * @param leftShift 左移位数，用于指定要设置的二进制位
     * @return 设置后的整数
     */
    public static int bitAdd(int src, int leftShift) {
        return src | (1 << leftShift);
    }

    /**
     * 检查指定位置的二进制位是否为 1。
     *
     * @param src       源整数
     * @param leftShift 左移位数，用于指定要检查的二进制位
     * @return 如果指定位置的二进制位为 1，则返回 true；否则返回 false
     */
    public static boolean bitContain(int src, int leftShift) {
        return (src & (1 << leftShift)) != 0;
    }

    /**
     * 检查 long 值是否可以安全地转换为 int 类型。
     *
     * @param maxValue 要检查的 long 值
     * @return 如果可以转换为 int 类型，则返回 true；否则返回 false
     */
    public static boolean canBeInt(long maxValue) {
        return maxValue >= Integer.MIN_VALUE && maxValue <= Integer.MAX_VALUE;
    }

    /**
     * 计算 10 的 n 次幂
     *
     * @param n 幂次
     * @return 10 的 n 次幂
     */
    private static int powerOfTen(int n) {
        int result = 1;
        for (int i = 0; i < n; i++) {
            result *= 10;
        }
        return result;
    }

    /**
     * 在指定的 10 的幂次位上填充 1。
     *
     * @param value   源整数
     * @param bitFlag 10 的幂次位
     * @return 填充后的整数
     * @throws IllegalArgumentException 如果 bitFlag 小于 0
     */
    public static int tenPowerFill(int value, int bitFlag) {
        if (bitFlag < 0) {
            throw new IllegalArgumentException("bitFlag 不能小于 0");
        }
        return value + powerOfTen(bitFlag);
    }

    /**
     * 检查指定的 10 的幂次位上是否有值。
     *
     * @param value   源整数
     * @param bitFlag 10 的幂次位
     * @return 如果指定的 10 的幂次位上有值，则返回 true；否则返回 false
     */
    public static boolean tenPowerBitContain(int value, int bitFlag) {
        int divisor = powerOfTen(bitFlag);
        return (value / divisor) % 10 > 0;
    }

    /**
     * 确保整数大于或等于 0。
     * 如果整数小于 0，则返回 0。
     *
     * @param value 要检查的整数
     * @return 大于或等于 0 的整数
     */
    public static int greaterOrEqualZero(int value) {
        return Math.max(value, 0);
    }

    /**
     * 将布尔值转换为字节值。
     * 如果布尔值为 true，则返回 1；否则返回 0。
     *
     * @param b 要转换的布尔值
     * @return 转换后的字节值
     */
    public static byte booleanToByte(Boolean b) {
        return (byte) (b ? 1 : 0);
    }

    /**
     * 检查两个 long 类型的数相乘是否会溢出。
     *
     * @param arg1 第一个乘数
     * @param arg2 第二个乘数
     * @return 如果相乘会溢出，则返回 true；否则返回 false
     */
    public static boolean isMultiplyOverflow(long arg1, long arg2) {
        if (arg1 == 0 || arg2 == 0) {
            return false;
        }
        long result = arg1 * arg2;
        return result / arg1 != arg2;
    }

    public static void main(String[] args) {
        long a = Long.MIN_VALUE;
        long b = -1;
        long c = a * b;
        boolean multiplyOverflow = isMultiplyOverflow(a, b);
        System.out.println(multiplyOverflow + " value=" + c);
    }
}